The present invention relates generally to software system performance diagnosis, and more particularly, to Method for Guarding a Monitoring Scope and Interpreting Partial Control Flow Context.
Debugging enterprise software is challenging due to growing complexity of programs and dependency among software components. Modern software often involves third-part components to compose the entire software package at the deployment. Also modern object-oriented programs use dynamic techniques for loading software packages such as dynamic class loading in Java. In such situations program analysis of software may not have the entire information regarding its execution. Such incompleteness of the analyzed program scope can introduce inaccuracy in the monitoring of application status.
In order to monitor application execution status efficiently, several approaches called call context encoding [1,2] were proposed. [1] Michael D. Bond and Kathryn S. McKinley. 2007. Probabilistic calling context. In Proceedings of the 22nd annual ACM SIGPLAN conference on Object-oriented programming systems and applications (OOPSLA '07, and [2] William N. Sumner, Yunhui Zheng, Dasarath Weeratunge, and Xiangyu Zhang. 2010. Precise calling context encoding. In Proceedings of the 32nd ACM/IEEE International Conference on Software Engineering—Volume 1 (ICSE '10), Vol. 1. ACM, New York, N.Y., USA.
[1] and [2] are prior arts that provide the monitoring of concise application status via calling context encoding. The methodology of [1] does not guarantee to provide deterministic and accurate encoding information. [2]'s approach is limited for object oriented programs because its encoding algorithm cannot handle dynamic dispatch and an incomplete control flow graph. When the program execution interleaves the code inside and outside of the program analysis, encoding value could be manipulated. This invention provides a new method to handle the execution of such unexpected code flow and provide deterministic and accurate encoding values.
[1] provides a simple scheme that encodes the executed code probabilistically using hash. This solution does not require program analysis. Instead, it blindly instruments any application code and generates hash values of the executed code. The corresponding downside of this simplicity is that the encoded value may not be easily and accurately decoded. Due to the usage of hash values, the decoding process is not deterministic and can fail in some cases due to the collision of encoded values.
[2] uses static analysis to precisely encode and decode application call context. The strength of this approach is that the encoded values can be deterministically and efficiently decoded based on program analysis. However, this approach does not work for object-oriented (OO) programs. Complexity and multiple components of OO-software make the static program analysis challenging and expensive. Any missing component due to cost of analysis or lack of accuracy leads to unexpected program control flow which can introduce inaccuracy of the encoded application status.
Another known approach has been proposed by [3] Martín Abadi, Mihai Budiu, Úlfar Erlingsson, and Jay Ligatti. 2009. Control-flow integrity principles, implementations, and applications. ACM Trans. Inf. Syst. Secur. 13, 1, Article 4 (November 2009), 40 pages. DOI=10.1145/1609956.1609960.
[3] proposes a security mechanism for detecting illegal code execution. We use a similar technique as one building block in a very different problem domain to track the transition between the in-scope (analyzed by program analysis) and out-of-scope (which is outside of program analysis) functions. Given the complexity of object oriented software, this scheme deals with incompleteness of program analysis. More importantly our scheme introduces the actions to recover a pre-violation call path and a post-violation call path after the detection of a violation. Such details are unique in our problem domain and it addresses the real challenge to cope with the execution of unexpected control flow.
Accordingly, there is a need for a solution for guarding a monitoring scope and interpreting partial control flow context that is not taught heretobefore.